// 14_async_await.rs
// Rust Async/Await 教程

use std::time::Duration;
use tokio;

// 注意：需要在 Cargo.toml 中添加 tokio 依赖才能运行此示例

#[tokio::main]
async fn main() {
    // 1. 异步函数基础
    println!("=== 1. 异步函数基础 ===");
    
    // 调用异步函数
    let result = simple_async_function().await;
    println!("异步函数返回结果: {}", result);
    
    // 2. 异步任务并发执行
    println!("\n=== 2. 异步任务并发执行 ===");
    
    let task1 = async_task(1, 2);
    let task2 = async_task(2, 1);
    
    // 并发执行两个任务
    let (result1, result2) = tokio::join!(task1, task2);
    println!("任务1结果: {}, 任务2结果: {}", result1, result2);
    
    // 3. 异步任务顺序执行
    println!("\n=== 3. 异步任务顺序执行 ===");
    
    let result1 = async_task(1, 1).await;
    let result2 = async_task(2, 1).await;
    println!("顺序执行结果: {}, {}", result1, result2);
    
    // 4. 错误处理
    println!("\n=== 4. 错误处理 ===");
    
    match fallible_async_task(true).await {
        Ok(value) => println!("成功: {}", value),
        Err(e) => println!("错误: {}", e),
    }
    
    match fallible_async_task(false).await {
        Ok(value) => println!("成功: {}", value),
        Err(e) => println!("错误: {}", e),
    }
    
    // 5. 异步流处理
    println!("\n=== 5. 异步流处理 ===");
    
    async_stream_example().await;
    
    // 6. 超时处理
    println!("\n=== 6. 超时处理 ===");
    
    match tokio::time::timeout(Duration::from_secs(3), long_running_task()).await {
        Ok(result) => println!("任务完成: {}", result),
        Err(_) => println!("任务超时"),
    }
    
    println!("\nAsync/Await 教程完成！");
}

// 简单的异步函数
async fn simple_async_function() -> i32 {
    // 模拟一些异步工作
    tokio::time::sleep(Duration::from_millis(100)).await;
    42
}

// 带参数的异步函数
async fn async_task(id: u32, delay_secs: u64) -> String {
    println!("任务 {} 开始执行", id);
    tokio::time::sleep(Duration::from_secs(delay_secs)).await;
    println!("任务 {} 执行完成", id);
    format!("任务{}结果", id)
}

// 可能失败的异步函数
async fn fallible_async_task(success: bool) -> Result<String, String> {
    tokio::time::sleep(Duration::from_millis(100)).await;
    if success {
        Ok("操作成功".to_string())
    } else {
        Err("操作失败".to_string())
    }
}

// 长时间运行的任务
async fn long_running_task() -> String {
    tokio::time::sleep(Duration::from_secs(5)).await;
    "长时间任务完成".to_string()
}

// 异步流示例
async fn async_stream_example() {
    // 创建一个异步流，每隔一秒产生一个值
    let mut counter = 0;
    loop {
        tokio::time::sleep(Duration::from_secs(1)).await;
        counter += 1;
        println!("流值: {}", counter);
        
        if counter >= 3 {
            break;
        }
    }
}